func go/types.under

79 uses

	go/types (current package)
		assignments.go#L97: 	if sig, _ := under(x.typ).(*Signature); sig != nil && sig.TypeParams().Len() > 0 {
		assignments.go#L267: 			if _, ok := under(T).(*Signature); ok {
		builtins.go#L152: 		switch t := arrayPtrDeref(under(x.typ)).(type) {
		builtins.go#L211: 			if isValid(under(x.typ)) {
		builtins.go#L330: 			if t, _ := under(typ).(*Basic); t != nil {
		builtins.go#L450: 			if t, _ := under(typ).(*Basic); t != nil {
		builtins.go#L941: 	switch u := under(t).(type) {
		builtins.go#L1033: 		if a, _ := under(p.base).(*Array); a != nil {
		call.go#L215: 				if t, _ := under(T).(*Interface); t != nil && !isTypeParam(T) {
		call.go#L811: 		if !isValid(under(x.typ)) {
		const.go#L38: 		check.representable(x, under(x.typ).(*Basic))
		conversions.go#L24: 		switch t, _ := under(T).(*Basic); {
		conversions.go#L148: 	Vu := under(V)
		conversions.go#L149: 	Tu := under(T)
		conversions.go#L164: 			if IdenticalIgnoreTags(under(V.base), under(T.base)) && !isTypeParam(V.base) && !isTypeParam(T.base) {
		conversions.go#L217: 			if a, _ := under(a.Elem()).(*Array); a != nil {
		conversions.go#L298: 	t, _ := under(typ).(*Basic)
		conversions.go#L303: 	t, _ := under(typ).(*Basic)
		conversions.go#L308: 	_, ok := under(typ).(*Pointer)
		conversions.go#L313: 	if s, _ := under(typ).(*Slice); s != nil {
		conversions.go#L314: 		t, _ := under(s.elem).(*Basic)
		decl.go#L452: 			if isValid(under(t)) {
		expr.go#L309: 		old.typ = under(typ).(*Basic)
		expr.go#L371: 	switch u := under(target).(type) {
		expr.go#L578: 	switch under(typ).(type) {
		expr.go#L928: 		if sig, _ := under(typ).(*Signature); sig != nil {
		expr.go#L1075: 		if _, ok := under(x.typ).(*Interface); !ok {
		gcsizes.go#L22: 	switch t := under(T).(type) {
		gcsizes.go#L102: 	switch t := under(T).(type) {
		index.go#L39: 		if sig, _ := under(x.typ).(*Signature); sig != nil && sig.TypeParams().Len() > 0 {
		index.go#L54: 	switch typ := under(x.typ).(type) {
		index.go#L77: 		if typ, _ := under(typ.base).(*Array); typ != nil {
		index.go#L128: 				if t, _ := under(t.base).(*Array); t != nil {
		index.go#L259: 		if u, _ := under(u.base).(*Array); u != nil {
		infer.go#L673: 			assert(debug && under(single.typ) == coreType(tpar))
		instantiate.go#L237: 	Vu := under(V)
		instantiate.go#L238: 	Tu := under(T)
		instantiate.go#L242: 	if p, _ := Vu.(*Pointer); p != nil && !isValid(under(p.base)) {
		instantiate.go#L350: 			if alt == nil && !t.tilde && Identical(t.typ, under(t.typ)) {
		lookup.go#L117: 		if _, ok := under(typ).(*Interface); ok {
		lookup.go#L167: 			switch t := under(typ).(type) {
		lookup.go#L338: 	methods := under(T).(*Interface).typeSet().methods // T must be an interface
		lookup.go#L358: 	if u, _ := under(V).(*Interface); u != nil {
		lookup.go#L499: 	if S, _ := under(derefStructPtr(T)).(*Struct); S != nil && !seen[S] {
		lookup.go#L514: 	p, _ := under(T).(*Pointer)
		lookup.go#L521: 	if p, _ := under(T).(*Pointer); isTypeParam(p.base) {
		lookup.go#L594: 	if p, _ := under(typ).(*Pointer); p != nil {
		lookup.go#L595: 		if _, ok := under(p.base).(*Struct); ok {
		methodset.go#L136: 			switch t := under(typ).(type) {
		object.go#L594: 			typ = under(typ)
		operand.go#L201: 						what = under(x.typ).(*Basic).name
		operand.go#L236: 	switch under(typ).(type) {
		operand.go#L326: 	Vu := under(V)
		operand.go#L327: 	Tu := under(T)
		predicates.go#L38: 	u, _ := under(t).(*Basic)
		predicates.go#L116: 	_, ok := under(t).(*Interface)
		predicates.go#L171: 	switch t := under(T).(type) {
		predicates.go#L214: 	switch u := under(t).(type) {
		sizes.go#L60: 	switch t := under(T).(type) {
		sizes.go#L168: 	switch t := under(T).(type) {
		sizes.go#L313: 		s := under(T).(*Struct)
		struct.go#L148: 				switch u := under(t).(type) {
		typeparam.go#L119: 	switch u := under(bound).(type) {
		typeset.go#L124: 			u = under(u)
		typeset.go#L127: 			assert(Identical(u, under(u)))
		typeset.go#L270: 		switch u := under(typ).(type) {
		typeset.go#L386: 		u := under(t.typ)
		typestring.go#L461: 					if t, _ := under(typ).(*Basic); t == nil || t.kind != String {
		typeterm.go#L121: 		u = under(u)
		typeterm.go#L161: 		ux = under(ux)
		typeterm.go#L165: 		uy = under(uy)
		typexpr.go#L175: 		if t, _ := under(typ).(*Interface); t != nil {
		under.go#L14: func under(t Type) Type {
		under.go#L43: 	yield(t, under(t))
		under.go#L79: 		return under(t) // untyped string remains untyped
		unify.go#L276: 		i, _ = under(x).(*Interface)
		unify.go#L436: 						if yc, _ := under(y).(*Chan); yc != nil && yc.dir != SendRecv {
		union.go#L97: 			u := under(t.typ)